package com.chenailin.www.serviceimpl;

import com.chenailin.www.dao.EnterpriseDao;
import com.chenailin.www.daoimpl.EnterpriseDaoImpl;
import com.chenailin.www.exception.BusinessException;
import com.chenailin.www.model.dto.EnterpriseDTO;
import com.chenailin.www.model.enums.EnterpriseRole;
import com.chenailin.www.model.pojo.Enterprise;
import com.chenailin.www.model.pojo.EnterpriseMember;
import com.chenailin.www.model.vo.EnterpriseVO;
import com.chenailin.www.service.EnterpriseService;

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author evi
 */
public class EnterpriseServiceImpl implements EnterpriseService {
    private final EnterpriseDao enterpriseDao = new EnterpriseDaoImpl();
    // TODO: 需要添加EnterpriseMemberDao实现
//     private final EnterpriseMemberDao enterpriseMemberDao = new EnterpriseMemberDaoImpl();

    @Override
    public Enterprise createEnterprise(EnterpriseDTO dto, Long creatorId) {
        // 验证企业名称是否已存在
        if (enterpriseDao.exists(dto.getName())) {
            throw new BusinessException("企业名称已存在");
        }

        // 创建企业
        Enterprise enterprise = new Enterprise();
        enterprise.setName(dto.getName());
        enterprise.setCreatorId(creatorId);
        enterprise.setCreateTime(new Date());
        enterprise.setUpdateTime(new Date());

        enterpriseDao.save(enterprise);

        // EnterpriseServiceImpl.java - 续
        // 自动添加创建者为所有者
        EnterpriseMember owner = new EnterpriseMember();
        owner.setEnterpriseId(enterprise.getId());
        owner.setUserId(creatorId);
        owner.setRole(EnterpriseRole.OWNER.code);
        owner.setJoinTime(new Date());
        // enterpriseMemberDao.save(owner);  // 需要实现EnterpriseMemberDao

        return enterprise;
    }

    @Override
    public Enterprise updateEnterprise(EnterpriseDTO dto, Long userId) {
        // 验证企业存在
        Enterprise enterprise = enterpriseDao.findById(dto.getId());
        if (enterprise == null) {
            throw new BusinessException("企业不存在");
        }

        // 检查权限：只有所有者可以修改企业信息
        // EnterpriseMember member = enterpriseMemberDao.findByEnterpriseAndUser(dto.getId(), userId);
        // if (member == null || member.getRole() != EnterpriseRole.OWNER.code) {
        //     throw new BusinessException("需要所有者权限");
        // }

        // 验证企业名称是否已存在（排除当前企业）
        if (!enterprise.getName().equals(dto.getName()) && enterpriseDao.exists(dto.getName())) {
            throw new BusinessException("企业名称已存在");
        }

        // 更新企业信息
        enterprise.setName(dto.getName());
        enterprise.setUpdateTime(new Date());

        enterpriseDao.update(enterprise);
        return enterprise;
    }

    @Override
    public void deleteEnterprise(Long id, Long userId) {
        // 验证企业存在
        Enterprise enterprise = enterpriseDao.findById(id);
        if (enterprise == null) {
            throw new BusinessException("企业不存在");
        }

        // 检查权限：只有所有者可以删除企业
        // EnterpriseMember member = enterpriseMemberDao.findByEnterpriseAndUser(id, userId);
        // if (member == null || member.getRole() != EnterpriseRole.OWNER.code) {
        //     throw new BusinessException("需要所有者权限");
        // }

        // 删除企业
        enterpriseDao.delete(id);

        // TODO: 删除企业相关数据（成员、通知等）
    }

    @Override
    public EnterpriseVO getEnterpriseById(Long id, Long userId) {
        // 验证企业存在
        Enterprise enterprise = enterpriseDao.findById(id);
        if (enterprise == null) {
            throw new BusinessException("企业不存在");
        }

        // 检查权限：必须是企业成员才能查看企业信息
        // EnterpriseMember member = enterpriseMemberDao.findByEnterpriseAndUser(id, userId);
        // if (member == null) {
        //     throw new BusinessException("您不是该企业的成员");
        // }

        return convertToVO(enterprise, userId);
    }

    @Override
    public List<EnterpriseVO> getUserEnterprises(Long userId) {
        // 获取用户所在的所有企业
        List<Enterprise> enterprises = enterpriseDao.findByUserId(userId);

        // 转换为VO对象
        return enterprises.stream()
                .map(enterprise -> convertToVO(enterprise, userId))
                .collect(Collectors.toList());
    }

    @Override
    public List<EnterpriseVO> getCreatedEnterprises(Long creatorId) {
        // 获取用户创建的所有企业
        List<Enterprise> enterprises = enterpriseDao.findByCreatorId(creatorId);

        // 转换为VO对象
        return enterprises.stream()
                .map(enterprise -> convertToVO(enterprise, creatorId))
                .collect(Collectors.toList());
    }

    @Override
    public List<EnterpriseVO> getOwnedEnterprises(Long userId) {
        // 获取用户创建的所有企业
        List<Enterprise> enterprises = enterpriseDao.findByCreatorId(userId);

        // 转换为VO对象
        return enterprises.stream()
                .map(enterprise -> convertToVO(enterprise, userId))
                .collect(Collectors.toList());
    }

//    @Override
//    public List<EnterpriseMemberVO> getEnterpriseMembers(Long enterpriseId, Long userId) {
//        // 验证企业存在
//        Enterprise enterprise = enterpriseDao.findById(enterpriseId);
//        if (enterprise == null) {
//            throw new BusinessException("企业不存在");
//        }
//
//        // 检查权限：必须是企业成员才能查看成员列表
//        EnterpriseMember currentMember = enterpriseMemberDao.findByEnterpriseAndUser(enterpriseId, userId);
//        if (currentMember == null) {
//            throw new BusinessException("您不是该企业的成员");
//        }
//
//        // 获取所有成员
//        List<EnterpriseMember> members = enterpriseMemberDao.findByEnterpriseId(enterpriseId);
//
//        // 转换为VO对象
//        return members.stream()
//                .map(this::convertMemberToVO)
//                .collect(Collectors.toList());
//    }

//    @Override
//    public void inviteMember(Long enterpriseId, EnterpriseMemberDTO dto, Long userId) {
//        // 验证企业存在
//        Enterprise enterprise = enterpriseDao.findById(enterpriseId);
//        if (enterprise == null) {
//            throw new BusinessException("企业不存在");
//        }
//
//        // 检查权限：只有所有者和管理员可以邀请成员
//        EnterpriseMember currentMember = enterpriseMemberDao.findByEnterpriseAndUser(enterpriseId, userId);
//        if (currentMember == null || (currentMember.getRole() != EnterpriseRole.OWNER.code &&
//                currentMember.getRole() != EnterpriseRole.ADMIN.code)) {
//            throw new BusinessException("您没有权限邀请成员");
//        }
//
//        // 检查被邀请用户是否存在
//        User invitedUser = userDao.findByEmail(dto.getEmail());
//        if (invitedUser == null) {
//            throw new BusinessException("被邀请用户不存在");
//        }
//
//        // 检查用户是否已经是成员
//        EnterpriseMember existingMember = enterpriseMemberDao.findByEnterpriseAndUser(enterpriseId, invitedUser.getId());
//        if (existingMember != null) {
//            throw new BusinessException("该用户已经是企业成员");
//        }
//
//        // 创建企业邀请
//        EnterpriseInvitation invitation = new EnterpriseInvitation();
//        invitation.setEnterpriseId(enterpriseId);
//        invitation.setEmail(dto.getEmail());
//        invitation.setRole(dto.getRole());
//        invitation.setInviteCode(generateInviteCode());
//        invitation.setCreatedBy(userId);
//        invitation.setExpiryTime(new Date(System.currentTimeMillis() + 7 * 24 * 60 * 60 * 1000)); // 7天有效期
//        invitation.setCreateTime(new Date());
//
//        // 保存邀请
//        enterpriseInvitationDao.save(invitation);
//
//        // TODO: 发送邀请邮件
//    }
//
//    @Override
//    public void joinEnterprise(String inviteCode, Long userId) {
//        // 验证邀请码
//        EnterpriseInvitation invitation = enterpriseInvitationDao.findByInviteCode(inviteCode);
//        if (invitation == null) {
//            throw new BusinessException("邀请码不存在");
//        }
//
//        // 检查邀请码是否过期
//        if (invitation.getExpiryTime().before(new Date())) {
//            throw new BusinessException("邀请码已过期");
//        }
//
//        // 验证企业存在
//        Enterprise enterprise = enterpriseDao.findById(invitation.getEnterpriseId());
//        if (enterprise == null) {
//            throw new BusinessException("企业不存在");
//        }
//
//        // 检查用户是否已经是成员
//        EnterpriseMember existingMember = enterpriseMemberDao.findByEnterpriseAndUser(invitation.getEnterpriseId(), userId);
//        if (existingMember != null) {
//            throw new BusinessException("您已经是该企业的成员");
//        }
//
//        // 检查邀请的邮箱是否匹配当前用户
//        User user = userDao.findById(userId);
//        if (user == null || !user.getEmail().equals(invitation.getEmail())) {
//            throw new BusinessException("邀请码不是发给您的");
//        }
//
//        // 添加成员
//        EnterpriseMember member = new EnterpriseMember();
//        member.setEnterpriseId(invitation.getEnterpriseId());
//        member.setUserId(userId);
//        member.setRole(invitation.getRole());
//        member.setJoinTime(new Date());
//        enterpriseMemberDao.save(member);
//
//        // 更新企业成员数量
//        enterprise.setMemberCount(enterprise.getMemberCount() + 1);
//        enterpriseDao.update(enterprise);
//
//        // 删除已使用的邀请
//        enterpriseInvitationDao.delete(invitation.getId());
//    }
//
//    @Override
//    public void updateMemberRole(Long memberId, EnterpriseMemberDTO dto, Long userId) {
//        // 验证成员记录存在
//        EnterpriseMember member = enterpriseMemberDao.findById(memberId);
//        if (member == null) {
//            throw new BusinessException("成员记录不存在");
//        }
//
//        // 检查权限：只有所有者可以修改角色
//        EnterpriseMember currentMember = enterpriseMemberDao.findByEnterpriseAndUser(member.getEnterpriseId(), userId);
//        if (currentMember == null || currentMember.getRole() != EnterpriseRole.OWNER.code) {
//            throw new BusinessException("您没有权限修改成员角色");
//        }
//
//        // 不能修改所有者角色
//        if (member.getRole() == EnterpriseRole.OWNER.code) {
//            throw new BusinessException("不能修改所有者角色");
//        }
//
//        // 不能自己修改自己的角色
//        if (member.getUserId().equals(userId)) {
//            throw new BusinessException("不能修改自己的角色");
//        }
//
//        // 更新角色
//        member.setRole(dto.getRole());
//        enterpriseMemberDao.update(member);
//    }
//
//    @Override
//    public void leaveEnterprise(Long enterpriseId, Long userId) {
//        // 验证企业存在
//        Enterprise enterprise = enterpriseDao.findById(enterpriseId);
//        if (enterprise == null) {
//            throw new BusinessException("企业不存在");
//        }
//
//        // 检查用户是否是企业成员
//        EnterpriseMember member = enterpriseMemberDao.findByEnterpriseAndUser(enterpriseId, userId);
//        if (member == null) {
//            throw new BusinessException("您不是该企业的成员");
//        }
//
//        // 所有者不能直接离开企业，需要先转移所有权
//        if (member.getRole() == EnterpriseRole.OWNER.code) {
//            throw new BusinessException("企业所有者不能直接离开企业，请先转移所有权");
//        }
//
//        // 离开企业
//        enterpriseMemberDao.delete(member.getId());
//
//        // 更新企业成员数量
//        enterprise.setMemberCount(Math.max(0, enterprise.getMemberCount() - 1));
//        enterpriseDao.update(enterprise);
//    }
//
//    @Override
//    public void removeMember(Long enterpriseId, Long memberId, Long userId) {
//        // 验证企业存在
//        Enterprise enterprise = enterpriseDao.findById(enterpriseId);
//        if (enterprise == null) {
//            throw new BusinessException("企业不存在");
//        }
//
//        // 检查要移除的用户是否是企业成员
//        EnterpriseMember memberToRemove = enterpriseMemberDao.findByEnterpriseAndUser(enterpriseId, memberId);
//        if (memberToRemove == null) {
//            throw new BusinessException("要移除的用户不是企业成员");
//        }
//
//        // 检查操作者权限
//        EnterpriseMember currentMember = enterpriseMemberDao.findByEnterpriseAndUser(enterpriseId, userId);
//        if (currentMember == null) {
//            throw new BusinessException("您不是该企业的成员");
//        }
//
//        // 检查权限规则：
//        // 1. 所有者可以移除任何人（除了自己）
//        // 2. 管理员可以移除普通成员，但不能移除所有者或其他管理员
//        // 3. 普通成员不能移除任何人
//
//        if (currentMember.getRole() == EnterpriseRole.OWNER.code) {
//            // 所有者不能移除自己
//            if (memberId.equals(userId)) {
//                throw new BusinessException("企业所有者不能移除自己，请先转移所有权");
//            }
//        } else if (currentMember.getRole() == EnterpriseRole.ADMIN.code) {
//            // 管理员只能移除普通成员
//            if (memberToRemove.getRole() != EnterpriseRole.MEMBER.code) {
//                throw new BusinessException("您没有权限移除此成员");
//            }
//        } else {
//            // 普通成员不能移除任何人
//            throw new BusinessException("您没有权限移除成员");
//        }
//
//        // 移除成员
//        enterpriseMemberDao.delete(memberToRemove.getId());
//
//        // 更新企业成员数量
//        enterprise.setMemberCount(Math.max(0, enterprise.getMemberCount() - 1));
//        enterpriseDao.update(enterprise);
//    }

    // 辅助方法：将Enterprise转换为EnterpriseVO
    private EnterpriseVO convertToVO(Enterprise enterprise, Long userId) {
        EnterpriseVO vo = new EnterpriseVO();
        vo.setId(enterprise.getId());
        vo.setName(enterprise.getName());
//        vo.setDescription(enterprise.getDescription());
//        vo.setLogoUrl(enterprise.getLogoUrl());
        vo.setCreatorId(enterprise.getCreatorId());

//        // 获取创建者信息
//        User creator = userDao.findById(enterprise.getCreatorId());
//        if (creator != null) {
//            vo.setCreatorName(creator.getUsername());
//            vo.setCreatorAvatar(creator.getAvatar());
//        }

//        vo.setMemberCount(enterprise.getMemberCount());
        vo.setCreateTime(enterprise.getCreateTime());
        vo.setUpdateTime(enterprise.getUpdateTime());

        // 设置
        return vo;
    }

//    private EnterpriseVO convertToVO(Enterprise enterprise, Long userId) {
//        EnterpriseVO vo = new EnterpriseVO();
//        vo.setId(enterprise.getId());
//        vo.setName(enterprise.getName());
//        vo.setCreatorId(enterprise.getCreatorId());
//        vo.setCreateTime(enterprise.getCreateTime());
//        vo.setUpdateTime(enterprise.getUpdateTime());
//
//        // 设置成员数量
//        // vo.setMemberCount(enterpriseMemberDao.countMembers(enterprise.getId()));
//
//        // 设置当前用户角色
//        // EnterpriseMember member = enterpriseMemberDao.findByEnterpriseAndUser(enterprise.getId(), userId);
//        // if (member != null) {
//        //     vo.setCurrentUserRole(member.getRole());
//        // }
//
//        return vo;
//    }
}